package handler

import (
    "context"
    "device-modbus/internal/biz/model"
    "device-modbus/internal/logic"
    "fmt"
    "strconv"

    "github.com/cloudwego/hertz/pkg/app"
    "github.com/cloudwego/hertz/pkg/common/utils"
    "github.com/cloudwego/hertz/pkg/protocol/consts"
)

// CommandHandler 指令配置API处理器
type CommandHandler struct {
    cmdLogic *logic.CommandLogic
}

// NewCommandHandler 创建指令配置API处理器
func NewCommandHandler(cmdLogic *logic.CommandLogic) *CommandHandler {
    return &CommandHandler{
        cmdLogic: cmdLogic,
    }
}

// GetDeviceCommands 获取设备的所有指令配置
// @Summary 获取设备的所有指令配置
// @Description 获取指定设备的所有数据采集指令配置
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Success 200 {array} model.DeviceCommand
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands [get]
func (h *CommandHandler) GetDeviceCommands(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    if deviceID == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "设备ID不能为空"})
        return
    }

    commands, err := h.cmdLogic.GetDeviceCommands(ctx, deviceID)
    if err != nil {
        c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
        return
    }

    c.JSON(consts.StatusOK, commands)
}

// CreateDeviceCommand 创建设备指令配置
// @Summary 创建设备指令配置
// @Description 为指定设备创建新的数据采集指令配置
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Param command body model.DeviceCommand true "指令配置"
// @Success 201 {object} utils.H
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands [post]
func (h *CommandHandler) CreateDeviceCommand(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    if deviceID == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "设备ID不能为空"})
        return
    }

    var cmd model.DeviceCommand
    if err := c.BindJSON(&cmd); err != nil {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "无效的请求参数: " + err.Error()})
        return
    }

    // 确保设备ID一致
    cmd.DeviceID = deviceID

    if err := h.cmdLogic.CreateDeviceCommand(ctx, &cmd); err != nil {
        c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
        return
    }

    c.JSON(consts.StatusCreated, utils.H{
        "message": "指令创建成功",
        "command": cmd,
    })
}

// BatchCreateDeviceCommands 批量创建设备指令配置
// @Summary 批量创建设备指令配置
// @Description 为指定设备批量创建数据采集指令配置
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Param commands body []model.DeviceCommand true "指令配置列表"
// @Success 201 {object} utils.H
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands/batch [post]
func (h *CommandHandler) BatchCreateDeviceCommands(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    if deviceID == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "设备ID不能为空"})
        return
    }

    var cmds []*model.DeviceCommand
    if err := c.BindJSON(&cmds); err != nil {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "无效的请求参数: " + err.Error()})
        return
    }

    // 确保所有指令的设备ID一致
    for _, cmd := range cmds {
        cmd.DeviceID = deviceID
    }

    if err := h.cmdLogic.BatchCreateDeviceCommands(ctx, cmds); err != nil {
        c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
        return
    }

    c.JSON(consts.StatusCreated, utils.H{
        "message": "指令批量创建成功",
        "count":   len(cmds),
    })
}

// UpdateDeviceCommand 更新设备指令配置
// @Summary 更新设备指令配置
// @Description 更新指定设备的指定指令配置
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Param name path string true "指令名称"
// @Param command body model.DeviceCommand true "更新的指令配置"
// @Success 200 {object} utils.H
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands/{name} [put]
func (h *CommandHandler) UpdateDeviceCommand(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    name := c.Param("name")
    if deviceID == "" || name == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "设备ID和指令名称不能为空"})
        return
    }

    var cmd model.DeviceCommand
    if err := c.BindJSON(&cmd); err != nil {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "无效的请求参数: " + err.Error()})
        return
    }

    // 确保设备ID和指令名称一致
    cmd.DeviceID = deviceID
    cmd.Name = name

    if err := h.cmdLogic.UpdateDeviceCommand(ctx, &cmd); err != nil {
        c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
        return
    }

    c.JSON(consts.StatusOK, utils.H{
        "message": "指令更新成功",
        "command": cmd,
    })
}

// DeleteDeviceCommand 删除设备指令配置
// @Summary 删除设备指令配置
// @Description 删除指定设备的指定指令配置
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Param name path string true "指令名称"
// @Success 200 {object} utils.H
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands/{name} [delete]
func (h *CommandHandler) DeleteDeviceCommand(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    name := c.Param("name")
    if deviceID == "" || name == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "设备ID和指令名称不能为空"})
        return
    }

    if err := h.cmdLogic.DeleteDeviceCommand(ctx, deviceID, name); err != nil {
        c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
        return
    }

    c.JSON(consts.StatusOK, utils.H{"message": "指令删除成功"})
}

// ToggleCommandEnabled 启用/禁用设备指令
// @Summary 启用/禁用设备指令
// @Description 启用或禁用指定设备的指定指令
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Param name path string true "指令名称"
// @Param enabled query bool true "是否启用"
// @Success 200 {object} utils.H
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands/{name}/enabled [patch]
func (h *CommandHandler) ToggleCommandEnabled(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    name := c.Param("name")
    enabledStr := c.Query("enabled")
    if deviceID == "" || name == "" || enabledStr == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "参数不完整"})
        return
    }

    enabled, err := strconv.Atoi(enabledStr)
    if err != nil {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "无效的enabled参数"})
        return
    }

    if err := h.cmdLogic.ToggleCommandEnabled(ctx, deviceID, name, enabled); err != nil {
        c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
        return
    }

    status := "启用"
    if enabled == 0 {
        status = "禁用"
    }

    c.JSON(consts.StatusOK, utils.H{
        "message": fmt.Sprintf("指令%s成功", status),
        "command": name,
        "enabled": enabled,
    })
}

// SendImmediateCommand 发送即时指令
// @Summary 发送即时指令
// @Description 向指定设备发送即时指令并获取响应
// @Tags commands
// @Accept json
// @Produce json
// @Param device_id path string true "设备ID"
// @Param name path string true "指令名称"
// @Success 200 {object} utils.H
// @Failure 400 {object} utils.H
// @Failure 500 {object} utils.H
// @Router /devices/{device_id}/commands/{name}/execute [post]
func (h *CommandHandler) SendImmediateCommand(ctx context.Context, c *app.RequestContext) {
    deviceID := c.Param("device_id")
    name := c.Param("name")
    if deviceID == "" || name == "" {
        c.JSON(consts.StatusBadRequest, utils.H{"error": "设备ID和指令名称不能为空"})
        return
    }

    //// 这里应该调用服务器的SendImmediateCommand方法
    //// 假设我们有一个全局的server实例或者通过依赖注入获取
    //response, err := server.SendImmediateCommand(deviceID, name)
    //if err != nil {
    //    c.JSON(consts.StatusInternalServerError, utils.H{"error": err.Error()})
    //    return
    //}

    //c.JSON(consts.StatusOK, utils.H{
    //    "message":  "指令执行成功",
    //    "command":  name,
    //    "response": response,
    //})
}
